/**
 * 性能优化工具类
 * 用于优化应用性能和资源使用
 */

class PerformanceOptimizer {
  /**
   * 构造函数
   */
  constructor() {
    this.resourceCache = new Map(); // 资源缓存
    this.loadingTasks = new Map();  // 加载任务
    this.frameRate = 30;            // 默认帧率
    this.isLowEndDevice = false;    // 是否低端设备
    this.memoryWarningCount = 0;    // 内存警告计数
    
    // 初始化
    this.init();
  }

  /**
   * 初始化
   */
  init() {
    // 检测设备性能
    this.detectDevicePerformance();
    
    // 监听内存警告
    this.listenMemoryWarning();
    
    console.log('性能优化器初始化完成');
  }

  /**
   * 检测设备性能
   */
  detectDevicePerformance() {
    try {
      const systemInfo = uni.getSystemInfoSync();
      console.log('系统信息:', systemInfo);
      
      // 根据设备信息判断是否为低端设备
      // 这里的判断逻辑可以根据实际情况调整
      if (
        systemInfo.platform === 'android' && 
        (systemInfo.system.toLowerCase().indexOf('android 5') !== -1 || 
         systemInfo.system.toLowerCase().indexOf('android 6') !== -1)
      ) {
        this.isLowEndDevice = true;
        this.frameRate = 24; // 降低帧率
      }
      
      // iOS低端设备判断
      if (
        systemInfo.platform === 'ios' && 
        parseInt(systemInfo.system.replace(/^iOS /, '')) < 11
      ) {
        this.isLowEndDevice = true;
        this.frameRate = 24; // 降低帧率
      }
      
      console.log('设备性能检测结果:', this.isLowEndDevice ? '低端设备' : '高端设备');
    } catch (error) {
      console.error('设备性能检测失败:', error);
    }
  }

  /**
   * 监听内存警告
   */
  listenMemoryWarning() {
    // 微信小程序支持内存警告监听
    if (typeof wx !== 'undefined' && wx.onMemoryWarning) {
      wx.onMemoryWarning(res => {
        console.warn('内存警告:', res.level);
        this.memoryWarningCount++;
        
        // 根据警告级别和次数采取不同措施
        if (res.level === 10 || this.memoryWarningCount > 3) {
          // 严重警告，清理资源
          this.clearUnusedResources();
        }
      });
    }
  }

  /**
   * 清理未使用的资源
   */
  clearUnusedResources() {
    console.log('清理未使用资源');
    
    // 清理资源缓存
    const currentTime = Date.now();
    const expireTime = 5 * 60 * 1000; // 5分钟过期
    
    this.resourceCache.forEach((value, key) => {
      if (currentTime - value.lastUsed > expireTime) {
        this.resourceCache.delete(key);
        console.log('清理资源:', key);
      }
    });
    
    // 主动触发垃圾回收（仅供参考，实际效果取决于JS引擎）
    if (typeof global !== 'undefined' && global.gc) {
      global.gc();
    }
  }

  /**
   * 优化渲染性能
   * @param {Function} renderFunction 渲染函数
   * @returns {Function} 优化后的渲染函数
   */
  optimizeRendering(renderFunction) {
    let lastFrameTime = 0;
    const frameInterval = 1000 / this.frameRate;
    
    return (timestamp) => {
      // 控制帧率
      if (timestamp - lastFrameTime < frameInterval) {
        return;
      }
      
      lastFrameTime = timestamp;
      renderFunction(timestamp);
    };
  }

  /**
   * 资源预加载
   * @param {Array} resources 资源列表，每项包含url和type
   * @returns {Promise} 加载完成的Promise
   */
  preloadResources(resources) {
    return new Promise((resolve, reject) => {
      if (!resources || resources.length === 0) {
        resolve([]);
        return;
      }
      
      const tasks = resources.map(resource => this.loadResource(resource.url, resource.type));
      
      Promise.all(tasks)
        .then(results => {
          console.log('资源预加载完成');
          resolve(results);
        })
        .catch(error => {
          console.error('资源预加载失败:', error);
          reject(error);
        });
    });
  }

  /**
   * 加载单个资源
   * @param {String} url 资源URL
   * @param {String} type 资源类型（image, model, audio等）
   * @returns {Promise} 加载完成的Promise
   */
  loadResource(url, type) {
    // 检查缓存
    if (this.resourceCache.has(url)) {
      const cachedResource = this.resourceCache.get(url);
      cachedResource.lastUsed = Date.now(); // 更新最后使用时间
      return Promise.resolve(cachedResource.data);
    }
    
    // 检查是否已有加载任务
    if (this.loadingTasks.has(url)) {
      return this.loadingTasks.get(url);
    }
    
    // 创建新的加载任务
    let loadTask;
    
    switch (type) {
      case 'image':
        loadTask = this.loadImage(url);
        break;
      case 'model':
        loadTask = this.loadModel(url);
        break;
      default:
        loadTask = Promise.reject(new Error('不支持的资源类型:' + type));
    }
    
    // 记录加载任务
    this.loadingTasks.set(url, loadTask);
    
    // 任务完成后处理
    loadTask
      .then(data => {
        // 缓存资源
        this.resourceCache.set(url, {
          data,
          lastUsed: Date.now()
        });
        
        // 移除加载任务记录
        this.loadingTasks.delete(url);
        
        return data;
      })
      .catch(error => {
        // 移除加载任务记录
        this.loadingTasks.delete(url);
        throw error;
      });
    
    return loadTask;
  }

  /**
   * 加载图片
   * @param {String} url 图片URL
   * @returns {Promise} 加载完成的Promise
   */
  loadImage(url) {
    return new Promise((resolve, reject) => {
      uni.getImageInfo({
        src: url,
        success: (res) => {
          resolve(res);
        },
        fail: (err) => {
          console.error('图片加载失败:', url, err);
          reject(err);
        }
      });
    });
  }

  /**
   * 加载模型（示例，实际实现可能不同）
   * @param {String} url 模型URL
   * @returns {Promise} 加载完成的Promise
   */
  loadModel(url) {
    // 这里只是一个示例，实际加载模型的逻辑需要根据具体使用的3D库来实现
    return new Promise((resolve, reject) => {
      // 模拟加载过程
      setTimeout(() => {
        resolve({ url, loaded: true });
      }, 500);
    });
  }

  /**
   * 获取当前性能状态
   * @returns {Object} 性能状态对象
   */
  getPerformanceStatus() {
    return {
      isLowEndDevice: this.isLowEndDevice,
      frameRate: this.frameRate,
      memoryWarningCount: this.memoryWarningCount,
      cachedResourceCount: this.resourceCache.size,
      loadingTaskCount: this.loadingTasks.size
    };
  }

  /**
   * 应用低端设备优化
   * @param {Object} options 优化选项
   */
  applyLowEndOptimizations(options = {}) {
    if (!this.isLowEndDevice) return;
    
    console.log('应用低端设备优化');
    
    // 可以根据传入的选项应用不同的优化策略
    // 例如：降低模型精度、禁用某些特效等
    
    // 示例：调整渲染质量
    if (options.renderer) {
      options.renderer.setPixelRatio(1);
    }
    
    // 示例：降低阴影质量
    if (options.shadows) {
      // 实现降低阴影质量的逻辑
    }
  }
}

// 创建单例
let instance = null;

/**
 * 获取性能优化器实例
 * @returns {PerformanceOptimizer} 性能优化器实例
 */
export const getPerformanceOptimizer = () => {
  if (!instance) {
    instance = new PerformanceOptimizer();
  }
  return instance;
};

export default PerformanceOptimizer;